Performance polymorphism

In an interactive functional programming environment with a Milner-style polymorphic type system (Milner 1978), a modification to one definition may imply changes in the types of other definitions. A polymorphic typechecker must carry out some re-typechecking to determine all of these changes. This paper presents a new typechecking algorithm which performs fine-grained re-typechecking based on analysis of individual type constraints. The new algorithm is compared with that of Nikhil (Nikhil 1985), which performs re-typechecking of entire definitions. 1 Background and Motivation The first author has constructed a programming environment, called glide, to support exploratory programming in a purely functional lazily-evaluated language. The glide language is similar to Miranda (Turner 1985). A glide program is a collection of definitions and an expression using them. Programming in glide involves introducing new definitions, performing computations involving the current definitions, and modifying definitions. The novel features of the glide environment include its debugging tools and its polymorphic typecbecker. The debugging tools have been described elsewhere (Toyn 1986). The typechecker imposes a Milner-style polymorphic type system (Milner 1978) without introducing long delays that would disrupt exploratory programming. In Practical Polymorphism (Nikhil 1985), Nikhil presents an algorithm that addresses the re-typechecking problem. His algorithm is based on the observation that if a definition does not use a modified definition, either directly or indirectly, then its type cannot be affected by changes in the type of the modified definition. This algorithm identifies those definitions whose types might change from the dependency graph of the program. Only the identified definitions are re-typechecked. An early version of glide used Nikhil's re-typechecking algorithm. However, an automatic loading mechanism was subsequently designed for glide which interacted badly with Nikhil's algorithm. In each session, needed definitions have to be loaded from the file system into the programming environment before they can be used. As each definition is loaded, some previously loaded definitions may have to be retypechecked. To minimize re-typechecking, it is best to load definitions at the leaves of the dependency graph before those higher up the graph. But glide's automatic loading mechanism causes definitions to be loaded only when they are first needed in a computation, that is from the root of the dependency graph down towards the leaves. So worst-case behaviour was always obtained from the re-typechecking algorithm. Rather than change the loading mechanism, the problem was solved by an improved re-typechecking algorithm as described here.